home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 June: Reference Library / Dev.CD Jun 99 RL Disk 1.toast / Technical Documentation / Develop / develop Issue 28 / develop Issue 28 code / MacApp Debugging / TwistDownLists / UTwistDownDocument.cp < prev    next >
Encoding:
Text File  |  1996-09-23  |  76.0 KB  |  2,147 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. // UTwistDownDocument.cp
  3. // ETO20 MacApp 3.3.1, MPW 3.4.1
  4. // Copyright ©1994-1996 Conrad Kopala
  5. // Twist Down Lists version 2.0a0 7/15/96
  6. //----------------------------------------------------------------------------------------
  7.  
  8. #ifndef __UTWISTDOWNDOCUMENT__
  9. #include "UTwistDownDocument.h"
  10. #endif
  11.  
  12. #ifndef __UPROGRESSINDICATORS__
  13. #include "UProgressIndicators.h"
  14. #endif
  15.  
  16. #ifndef __UTWISTDOWNAPP__
  17. #include "UTwistDownApp.h"
  18. #endif
  19.  
  20. #ifndef __UTWISTDOWNELEMENT__
  21. #include "UTwistDownElement.h"
  22. #endif
  23.  
  24. #ifndef __UTWISTDOWNCONTROL__
  25. #include "UTwistDownControl.h"
  26. #endif
  27.  
  28. #ifndef __UTWISTDOWNVIEW__
  29. #include "UTwistDownView.h"
  30. #endif
  31.  
  32. //MacApp stuff
  33.  
  34. #ifndef __UDEBUG__
  35. #include "UDebug.h"        //PPC
  36. #endif
  37.  
  38. #ifndef __UMACAPPUTILITIES__
  39. #include "UMacAppUtilities.h"
  40. #endif
  41.  
  42. #ifndef __UMENUMGR__
  43. #include "UMenuMgr.h"
  44. #endif
  45.  
  46. #ifndef __UPRINTING__
  47. #include "UPrinting.h"
  48. #endif
  49.  
  50. #ifndef __UVIEWSERVER__
  51. #include "UViewServer.h"
  52. #endif
  53.  
  54. #ifndef __UWINDOW__
  55. #include "UWindow.h"
  56. #endif
  57.  
  58. //ToolBox stuff
  59. #ifndef __ERRORS__
  60. #include "Errors.h"
  61. #endif
  62.  
  63. #ifndef __FILES__
  64. #include "Files.h"
  65. #endif
  66.  
  67. #ifndef __FONTS__    
  68. #include "Fonts.h"
  69. #endif
  70.  
  71. #ifndef __QUICKDRAW__
  72. #include "Quickdraw.h"
  73. #endif
  74.  
  75. #ifndef __AEREGISTRY__
  76. #include "AERegistry.h"
  77. #endif
  78.  
  79. //ANSI stuff
  80. //None
  81. //----------------------------------------------------------------------------------------
  82. // Constants:
  83.  
  84.  
  85. //========================================================================================
  86. // CLASS TTwistDownDocument
  87. //========================================================================================
  88. #undef Inherited
  89. #define Inherited TDocument
  90.  
  91. #pragma segment AOpen
  92. MA_DEFINE_CLASS_M1(TTwistDownDocument, Inherited);
  93.  
  94. //----------------------------------------------------------------------------------------
  95. // TTwistDownDocument constructor 
  96. //----------------------------------------------------------------------------------------
  97. #pragma segment AOpen
  98. TTwistDownDocument::TTwistDownDocument()  
  99. {
  100.  
  101. fVolume = NULL;
  102. fVolumeRefNumber = 0;
  103. fVolumeName = gEmptyString;
  104. fSameVolumeNumber = 0;
  105. fShowInvisibleFiles = FALSE;
  106.  
  107. fDependencies = NULL;
  108.  
  109. fNumberOfDirectoriesToLoad = 0;
  110. fNumberOfFilesToLoad = 0;
  111. fNumberOfItemsToLoad = 0;
  112.  
  113. fNumberOfDirectoriesInList = 0;
  114. fNumberOfFilesInList = 0;
  115. fNumberOfItemsInList = 0;
  116.  
  117. fTwistDownView = NULL;
  118. fHeadOfListElement = NULL;
  119. fTextStyle = gApplicationStyle;
  120.  
  121. fProgressBarIndicator = NULL;
  122. fUpdateAmount = 1;
  123. fProgressUpdateCounter = 0;
  124.  
  125. fSearchMethod = visibleList;
  126.  
  127. #if qDebug
  128. this -> PrintAppConstructorClassInfo();
  129. #endif
  130.  
  131. }
  132. //----------------------------------------------------------------------------------------
  133. // TTwistDownDocument::~TTwistDownDocument    
  134. //----------------------------------------------------------------------------------------
  135. #pragma segment AClose
  136. TTwistDownDocument::~TTwistDownDocument()
  137. {
  138.  
  139.     if (fDependencies)
  140.         fDependencies = (TSimpleDependencySpace*)(FreeIfObject(fDependencies));
  141.  
  142.     this -> FreeData();
  143.     
  144.     fHeadOfListElement = NULL;    //For safety's sake, set it to NULL. It has been freed.
  145.         
  146. #if qDebug
  147. this -> PrintAppDestructorClassInfo();
  148. #endif
  149. }
  150. //----------------------------------------------------------------------------------------
  151. // TTwistDownDocument::ITwistDownDocument: 
  152. //----------------------------------------------------------------------------------------
  153. #pragma segment AOpen
  154. void TTwistDownDocument::ITwistDownDocument(TVolume* itsVolume, Boolean showInvisibleFiles)
  155. {
  156.     this -> IDocument();    //IDocument contains a failure handler so any failure there will
  157.                                                 //get us out of ITwistDownDocument. 
  158.     
  159.     FailInfo fi;
  160.     Try(fi)
  161.     {
  162.  
  163.         fReopenAlert = TRUE;
  164.  
  165.         fDependencies = new TSimpleDependencySpace;    //Used for updating the progress indicator.
  166.         fDependencies -> ISimpleDependencySpace();
  167.         
  168.         fVolume = itsVolume;
  169.         CStr31 itsName;
  170.         itsVolume -> GetName(itsName);
  171.         this -> SetVolumeData(itsVolume -> GetVolRefNum(), itsName);    //This is the most likely
  172.                                                                                                                                     //source of a failure.
  173.  
  174.         fShowInvisibleFiles = showInvisibleFiles;
  175.     
  176.         fi.Success();
  177.     }
  178.     else // Recover
  179.     {
  180.         this->Free();
  181.         fi.ReSignal();                
  182.     }
  183.  
  184. }
  185. //----------------------------------------------------------------------------------------
  186. // TTwistDownDocument::CloseAndFree: 
  187. //----------------------------------------------------------------------------------------
  188. #pragma segment AClose
  189. void  TTwistDownDocument::CloseAndFree()
  190. {
  191.     if (fTwistDownView)
  192.         {
  193.             TWindow* theWindow = NULL;
  194.             theWindow = fTwistDownView -> GetWindow();
  195.             if (theWindow)
  196.                 gTwistDownApp -> RemoveWindowFromWindowsMenuList(theWindow);
  197.         }
  198.         
  199.     Inherited::CloseAndFree();
  200. }
  201. //----------------------------------------------------------------------------------------
  202. // TTwistDownDocument::GetDependencySpace: 
  203. //----------------------------------------------------------------------------------------
  204. #pragma segment AOpen
  205. TDependencySpace* TTwistDownDocument::GetDependencySpace()
  206. {
  207.     return fDependencies;
  208. }
  209. //----------------------------------------------------------------------------------------
  210. // TTwistDownDocument::Changed: 
  211. //----------------------------------------------------------------------------------------
  212. #pragma segment AReadFile
  213. void TTwistDownDocument::Changed(ChangeID theChange, TObject* changedBy)
  214. {
  215. //The following code is from TObject::Changed. I want to avoid the TDocument::Changed method
  216. //because it sets fChangeCount to something other than zero which causes the application to
  217. //ask the user about saving the document when it is closed and TwistDownLists does not save
  218. //documents. I also wanted to experiment with dependencies.
  219.  
  220.     TDependencySpace* itsDependencySpace = this -> GetDependencySpace();
  221.     if (itsDependencySpace)
  222.         itsDependencySpace -> NotifierChanged(this, theChange, changedBy);
  223. }
  224.  
  225. //----------------------------------------------------------------------------------------
  226. // TTwistDownDocument::FindDocument: analog of TFileBasedDocument::FindDocument    
  227. //----------------------------------------------------------------------------------------
  228. #pragma segment ARes
  229.  
  230. Boolean TTwistDownDocument::FindDocument(TVolume* aVolume)
  231. {
  232.     return fVolume -> IsSameVolume(aVolume);
  233. }
  234. //----------------------------------------------------------------------------------------
  235. // TTwistDownDocument::SetVolumeData: used by ITwistDownDocument    
  236. //----------------------------------------------------------------------------------------
  237. #pragma segment AOpen
  238. void TTwistDownDocument::SetVolumeData(short volumeRefNumber, CStr31 volumeName)
  239. {
  240.  
  241.     FailInfo fi;
  242.     Try(fi)
  243.         {
  244.             MAVolatile(HVolumeParam,    pb);
  245.  
  246.             fVolumeRefNumber = volumeRefNumber;
  247.             fVolumeName = volumeName;
  248.  
  249.             fSameVolumeNumber = gTwistDownApp -> GetNextDocumentNumber(volumeName);
  250.  
  251.             if (fSameVolumeNumber == 1)
  252.                 fTitle = volumeName;
  253.             else
  254.                 {
  255.                     CStr255 docNum;
  256.                     NumToString(fSameVolumeNumber, docNum);
  257.                     fTitle = volumeName;
  258.                     fTitle += " ";
  259.                     fTitle += docNum;
  260.                 }
  261.     
  262.             BlockSet((Ptr) & pb, sizeof(HVolumeParam), 0x00);    //For debugging fun  and games, comment
  263.                                                                                                                 //this statement out. You will discover
  264.                                                                                                                 //why parameter blocks should always be 
  265.                                                                                                                 //cleared before using them.
  266.  
  267.             pb.ioVRefNum = fVolumeRefNumber;
  268.             pb.ioVolIndex = 0;
  269.  
  270.             FailOSErr(PBHGetVInfoSync((HParmBlkPtr)&pb));
  271.             
  272.             fNumberOfDirectoriesToLoad = pb.ioVDirCnt;    
  273.             fNumberOfFilesToLoad = pb.ioVFilCnt;
  274.             fNumberOfItemsToLoad = fNumberOfDirectoriesToLoad + fNumberOfFilesToLoad;
  275.                     
  276.             long spaceRequiredForElements = fNumberOfItemsToLoad*(gTwistDownApp -> fTDElementClassSize);
  277.             long spaceRequiredForControls = fNumberOfDirectoriesToLoad*(gTwistDownApp -> fTDControlClassSize);            
  278.  
  279.             if (!HaveObjectHeapSpace(spaceRequiredForElements + spaceRequiredForControls +3*1024))
  280.                 Failure(memFullErr, 0);
  281.  
  282.         fi.Success();
  283.     }
  284. else // Recover
  285.     {
  286.         fi.ReSignal();                
  287.     }
  288.  
  289. }
  290. //----------------------------------------------------------------------------------------
  291. // TTwistDownDocument::SetUpdateAmount    
  292. //----------------------------------------------------------------------------------------
  293. #pragma segment AOpen
  294. void TTwistDownDocument::SetUpdateAmountTo(long updateAmount)
  295. {
  296. fUpdateAmount = updateAmount;
  297.  
  298. if (fProgressBarIndicator)
  299.     fProgressBarIndicator -> SetUpdateAmountTo(fUpdateAmount);
  300. }
  301. //----------------------------------------------------------------------------------------
  302. // TTwistDownDocument::FreeData: 
  303. //----------------------------------------------------------------------------------------
  304. #pragma segment ARes
  305. void TTwistDownDocument::FreeData()
  306. {
  307. fVolume = (TVolume*)(FreeIfObject(fVolume));                                        
  308. fVolumeName = gEmptyString;
  309.  
  310. if (fHeadOfListElement != NULL)
  311.     this -> FreeTwistDownList(fHeadOfListElement);
  312. }
  313. //----------------------------------------------------------------------------------------
  314. // TTwistDownDocument::FreeTwistDownList: 
  315. //----------------------------------------------------------------------------------------
  316. #pragma segment AClose
  317. void TTwistDownDocument::FreeTwistDownList(TTwistDownElement* twistDownElement)
  318. {
  319. TTwistDownElement* successorElement;
  320. TTwistDownElement* descendantElement;
  321.  
  322. while (twistDownElement != NULL) 
  323.     {
  324.         
  325.         successorElement = twistDownElement -> GetSuccessorElement();
  326.         descendantElement = twistDownElement -> GetDescendantElement();
  327.         
  328.         //Note: When the TTwistDownView is closed, the first thing it does is free all 
  329.         //the TTwistDownControls. The controls are freed before FreeTwistDownList is called.
  330.         //The TTwistDownControl::Free() method sets the fTwistDownControl field of
  331.         //the twistDownElement to NULL. Therefore, controls are not freed here.
  332.         
  333.         if (twistDownElement)
  334.             this -> DecrementItemsInList();
  335.             
  336.         twistDownElement = (TTwistDownElement*)FreeIfObject(twistDownElement);
  337.     
  338.         if (descendantElement != NULL)
  339.             this -> FreeTwistDownList(descendantElement);
  340.         
  341.         twistDownElement = successorElement;
  342.     }
  343. }
  344. //----------------------------------------------------------------------------------------
  345. // TTwistDownDocument::DoMakeViews: 
  346. //----------------------------------------------------------------------------------------
  347. #pragma segment AOpen
  348. void TTwistDownDocument::DoMakeViews(Boolean forPrinting)
  349. {
  350.  
  351. TWindow* aTwistDownWindow = NULL;    
  352. TTwistDownView* aTwistDownView = NULL;
  353.  
  354. FailInfo fi;
  355. Try(fi)
  356. {
  357.     if (!forPrinting)
  358.         {
  359.             FailNIL(aTwistDownWindow = gViewServer -> NewTemplateWindow(kTwistDownWindowID, this));    
  360.             
  361.             if (aTwistDownWindow != NULL)
  362.                 {
  363.                     aTwistDownView = (TTwistDownView*) (aTwistDownWindow -> FindSubView(kTwistDownViewID));
  364.                     fTwistDownView = aTwistDownView;
  365.     
  366.                     this -> AddPrintHandlerToView(fTwistDownView);
  367.  
  368.                     gTwistDownApp -> AddWindowToWindowsMenuList(aTwistDownWindow);
  369.                 }
  370.  
  371.         }
  372. #if qDebug        
  373.     else    //forPrinting    -Should never get here
  374.         ProgramBreak("ProgramBreak -DoMakeViews forPrinting = TRUE.");
  375. #endif
  376.         
  377.     fi.Success();
  378. }
  379. else // Recover
  380. {
  381.     fi.ReSignal();
  382. }        
  383.         
  384. }
  385. //----------------------------------------------------------------------------------------
  386. // TTwistDownDocument::AddPrintHandlerToView: 
  387. //----------------------------------------------------------------------------------------
  388. #pragma segment AOpen
  389. void TTwistDownDocument::AddPrintHandlerToView(TView* aView)
  390. {
  391.  
  392.     TPrintHandler* aPrintHandler = (TPrintHandler*)gPrintHandler -> Clone();
  393.  
  394.     aPrintHandler -> fView = aView;
  395.     aPrintHandler -> SetDefaultPrintInfo();
  396.     this -> AttachPrintHandler(aPrintHandler);
  397.     if (aView)
  398.         aView -> AttachPrintHandler(aPrintHandler);
  399.  
  400. //    TStdPrintHandler* printHandler = new TStdPrintHandler;
  401. //    printHandler -> IStdPrintHandler(this, aView, !kSquareDots, !kFixedSize, !kFixedSize);
  402. }
  403. //----------------------------------------------------------------------------------------
  404. // TTwistDownDocument::DoSetupMenus: 
  405. //----------------------------------------------------------------------------------------
  406. #pragma segment ARes
  407. void TTwistDownDocument::DoSetupMenus()
  408. {
  409.         
  410.     Inherited::DoSetupMenus();
  411.     
  412.     Enable(cSaveAs, FALSE);
  413.     Enable(cSaveCopy, FALSE);
  414.     Enable(cSave, FALSE);
  415.     Enable(cRevert, FALSE);
  416.     
  417. }
  418. //----------------------------------------------------------------------------------------
  419. // TTwistDownDocument::ReadDocument: 
  420. //----------------------------------------------------------------------------------------
  421. #pragma segment AReadFile
  422. void TTwistDownDocument::ReadDocument(Boolean forPrinting)
  423. {
  424. #pragma unused forPrinting
  425. MAVolatileInit(OSErr, savedError, 0);
  426. MAVolatileInit(long, savedMessage, 0);
  427.     
  428. //myOSErr is passed by reference. It is used to signal an out of memory condition when loading the list.
  429. OSErr myOSErr = noErr;
  430.  
  431. MAVolatileInit(long, volumeDirIndex, fsRtDirID);    //Must this be volatile?
  432. MAVolatileInit(short, indentLevel, 0);    //Must this be volatile?
  433.  
  434. CStr255 itsOperationString;
  435. GetIndString(itsOperationString, kProgressIndicatorOperationStrings, 3);
  436.  
  437. CStr255 itsSubjectString = fVolumeName;
  438. fProgressBarIndicator = NewProgressBarIndicator(itsOperationString, itsSubjectString);
  439.  
  440. this -> AddDependent(fProgressBarIndicator);
  441. fProgressBarIndicator -> PrepareToStart(TRUE);
  442.  
  443. long barLength = fProgressBarIndicator -> GetBarLength();
  444.  
  445. //The default value for fUpdateAmount is set to 1.                                
  446. //Unfortunately, if there are a lot of items to read and the progress bar is updated each time 
  447. //an item is read, it takes a long time to populate the list. With the following if statement,
  448. //the update amount is adjusted so that the progress bar is updated only when enough
  449. //progress has been made to update it by at least one pixel. This noticibly speeds things up. 
  450. //Comment out the following if statement and see for yourself. 
  451.  
  452. if (fNumberOfItemsToLoad > barLength)
  453.     {
  454.         long updateAmount = fNumberOfItemsToLoad/barLength;    
  455.         this -> SetUpdateAmountTo(updateAmount);    
  456.     }
  457.  
  458. fProgressBarIndicator -> Start(fNumberOfItemsToLoad);
  459.  
  460.     FailInfo fi;
  461.     Try(fi)
  462.     {
  463.  
  464.         fHeadOfListElement = this -> BuildTwistDownList(indentLevel, volumeDirIndex, myOSErr);
  465.         
  466.         if (myOSErr != noErr)
  467.             Failure(myOSErr, 0);
  468.             
  469.         fNumberOfFilesInList = fNumberOfItemsInList - fNumberOfDirectoriesInList;
  470.             
  471.         fi.Success();                                                
  472.     }
  473.     else
  474.     {
  475.     //Save the error info until after we've gotten rid of the progress indicator.
  476.     //Then we can signal Failure.
  477.         savedError = fi.error;
  478.         savedMessage = fi.message;
  479.         if (!savedMessage)
  480.             savedMessage = messageOpenFailed;
  481.  
  482.     }
  483.     
  484. if (fProgressBarIndicator != NULL)
  485.     {
  486.         fProgressBarIndicator -> Stop();
  487.         this -> RemoveDependent(fProgressBarIndicator);
  488.         fProgressBarIndicator = (TProgressBarIndicator*)FreeIfObject(fProgressBarIndicator);
  489.     }    
  490.  
  491. if (savedError != noErr)
  492.     Failure(savedError, savedMessage);
  493.  
  494. }
  495. //----------------------------------------------------------------------------------------
  496. // TTwistDownDocument::DoPostMakeViews: 
  497. //----------------------------------------------------------------------------------------
  498. #pragma segment AOpen
  499. void TTwistDownDocument::DoPostMakeViews(Boolean forPrinting)
  500. {
  501. Inherited::DoPostMakeViews(forPrinting);
  502.  
  503. TWindow* aTwistDownWindow = NULL;    
  504. aTwistDownWindow = fTwistDownView -> GetWindow();
  505. gTwistDownApp -> AddWindowToWindowsMenuList(aTwistDownWindow);
  506. }
  507. //----------------------------------------------------------------------------------------
  508. // TTwistDownDocument::BuildTwistDownList:    
  509. //----------------------------------------------------------------------------------------
  510. #pragma segment AReadFile
  511. TTwistDownElement* TTwistDownDocument::BuildTwistDownList(short indentLevel,
  512.                                                 long volumeDirIndex, OSErr& myOSErr)
  513. {
  514.  
  515. HFileInfo pb;
  516. CStr63 fileName = gEmptyString;
  517. FInfo theFinderInfo;
  518.         
  519. OSErr    status = noErr;            //status is set by PBGetCatInfoSync and signals no more files, i.e. we're done.
  520.  
  521. short dirIndex;
  522. TTwistDownElement* previousElement;
  523. TTwistDownElement* firstElement;
  524. TTwistDownElement* thisElement;
  525.  
  526. BlockSet((Ptr) & pb, sizeof(HFileInfo), 0x00);// zero-out our storage 
  527.  
  528. pb.ioNamePtr = fileName;    //Note that pb.ioNamePtr is a pointer to fileName.
  529. pb.ioVRefNum = fVolumeRefNumber;
  530. dirIndex = 1;
  531.  
  532. previousElement = NULL;
  533. firstElement = NULL;
  534. thisElement = NULL;
  535.  
  536. Boolean isVisible = FALSE;
  537. Boolean showIt = FALSE;
  538.  
  539. //The do-while loop scans the volume for all directories and files. It exits when 
  540. //    status == someError, most likely fnfErr (-43),
  541. //    myOSErr == someError, most likely memFullErr (-108), or
  542. //    fProgressBarIndicator -> IsStopped() == TRUE
  543. //
  544. //The status == fnfErr means the current loop is at the end of a chain in the hierarchy.
  545. //The myOSErr == memFullErr means we ran out of memory when MakeTwistDownElement attempted
  546. //to make a new twistDownElement.
  547. //The fProgressBarIndicator -> IsStopped() == TRUE condition means the user clicked on the
  548. //stop button in the progress indicator thus causing the loop to terminate early.
  549.  
  550. do 
  551. {
  552.  
  553. status = noErr;                            //Not absolutely necessary, cleared for debugging purposes.
  554. fileName = gEmptyString;        //Not absolutely necessary, cleared for debugging purposes.
  555. pb.ioFDirIndex = dirIndex;
  556. pb.ioDirID = volumeDirIndex;    //which happens to = fsRtDirID  root directory = 2
  557. status = PBGetCatInfoSync((CInfoPBPtr) &pb);
  558.  
  559. if (status == noErr)
  560.     {
  561.         if (fProgressBarIndicator != NULL)
  562.             {
  563.                 ++fProgressUpdateCounter;
  564.                 if (fProgressUpdateCounter >= fUpdateAmount)
  565.                     {
  566.                         fProgressUpdateCounter = 0;
  567.                         this -> Changed(mUpdateProgressBar, this);
  568.                     }
  569.             }
  570.  
  571.         isVisible = TRUE;    //Assume the item is visible.            
  572.         theFinderInfo = pb.ioFlFndrInfo;    
  573.         if ((theFinderInfo.fdFlags & kIsInvisible) == kIsInvisible)
  574.                 isVisible = FALSE;
  575.     
  576.         showIt = FALSE;        //Assume showIt is FALSE
  577.         if (fShowInvisibleFiles == TRUE || isVisible == TRUE)
  578.             showIt = TRUE;
  579.  
  580.         if (showIt == TRUE)
  581.             thisElement = this -> MakeTwistDownElement(previousElement,indentLevel,fileName,myOSErr);    
  582.                 
  583.         if (myOSErr == noErr) 
  584.             {
  585.                 if (firstElement == NULL)
  586.                     firstElement = thisElement;
  587.             
  588. //If thisElement is a folder and it is visible, descend the hierarchy by calling ourselves recursively. 
  589. //Store the first element in the new sub-list into thisElement's fDescendantElement. 
  590. //Note that thisElement's fHasSubList will be TRUE even if thisElement has no descendants 
  591. //(ie. nothing in the folder).
  592.  
  593.                 if ((pb.ioFlAttrib & ioDirMask) == ioDirMask && thisElement != NULL && showIt == TRUE) 
  594.                     {    
  595.                         thisElement -> SetHasSubListFlag();
  596.                         fNumberOfDirectoriesInList++;
  597.                         thisElement -> SetDescendantElementTo(this -> BuildTwistDownList(indentLevel + 1,pb.ioDirID, myOSErr));
  598.                     }
  599.                 ++dirIndex;
  600.                  previousElement = thisElement;    /* Set linkage for next file    */
  601.  
  602.             }    //end if (myOSErr == noErr) 
  603.     }    //end if (status == noErr)
  604.     
  605. } 
  606. while (status == noErr && myOSErr == noErr && fProgressBarIndicator -> IsStopped() == FALSE);
  607.     
  608. return (firstElement);
  609.  
  610. }
  611. //----------------------------------------------------------------------------------------
  612. // TTwistDownDocument::MakeTwistDownElement: 
  613. //----------------------------------------------------------------------------------------
  614. #pragma segment AReadFile
  615. TTwistDownElement* TTwistDownDocument::MakeTwistDownElement(TTwistDownElement* previousElement,
  616.                                                                                 short indentLevel,CStr63 displayedText, OSErr& myOSErr)
  617. {
  618.  
  619. TTwistDownElement* theNewElement = NULL;
  620.  
  621. FailInfo fi;
  622. Try(fi)
  623. {
  624.  
  625.     FailNIL(theNewElement = new TTwistDownElement);
  626.     theNewElement -> ITwistDownElement(this, indentLevel, displayedText);
  627.  
  628. /*    
  629.     //The FailHere test is commented out because it is being used in TTwistDownView::NewTwistDownControl
  630.     //to test failure handling there when opening a disk. Probably need a second fail here flag.
  631.     
  632.     //Note: To properly use the FailHere type test, always initialize the object whose failure 
  633.     //you're simulating before signalling Failure(errFailHere, 0);. If you don't the failure recovery
  634.     //won't work when it attempts to free the object.    
  635.     if (gFailHere)
  636.         {
  637.             CStr63 failHereText = "FailHere";
  638.             if (failHereText == displayedText)
  639.                 Failure(errFailHere, 0);
  640.         }    
  641. */
  642.  
  643.     this -> IncrementItemsInList();
  644.     theNewElement -> SetItemInList(fNumberOfItemsInList);                
  645.         
  646.     if (previousElement != NULL)
  647.         previousElement -> SetSuccessorElementTo(theNewElement);    
  648.         
  649.     fi.Success();
  650. }
  651.     // Recover. Do not ReSignal. If you do, the program will jump over any intervening 
  652.     // instances of BuildTwistDownList up to ReadDocument. As a consequence 
  653.     // fHeadOfListElement will be NULL and all the elements that were created by
  654.     // BuildTwistDownList will not be freed. Result = a memory leak like you've
  655.     // never seen before. Try it and see for yourself.
  656.                         
  657. else 
  658. {
  659.     theNewElement = (TTwistDownElement*)(FreeIfObject(theNewElement));
  660.     myOSErr = fi.error;
  661. }        
  662.  
  663. return theNewElement;
  664.  
  665. }
  666. //----------------------------------------------------------------------------------------
  667. // TTwistDownDocument::DisposeTwistDownElement: 
  668. //----------------------------------------------------------------------------------------
  669. #pragma segment AClose
  670. void TTwistDownDocument::DisposeTwistDownElement(TTwistDownElement* twistDownElement)
  671. {
  672. TTwistDownElement* successorElement;
  673. TTwistDownElement* descendantElement;
  674.         
  675. while (twistDownElement != NULL) 
  676. {
  677.     successorElement = twistDownElement -> GetSuccessorElement();
  678.     descendantElement = twistDownElement -> GetDescendantElement();
  679.     TTwistDownControl* twistDownControl = twistDownElement -> GetTwistDownControl();
  680.     if (twistDownControl != NULL)
  681.         {
  682.             fTwistDownView -> RemoveSubView(twistDownControl);
  683.             twistDownControl = (TTwistDownControl*)FreeIfObject(twistDownControl);
  684.             
  685.             //Note: The TTwistDownControl::Free() method sets the fTwistDownControl field of
  686.             //the twistDownElement to NULL;            
  687.  
  688.         }
  689.         
  690.     twistDownElement = (TTwistDownElement*)FreeIfObject(twistDownElement);
  691.     
  692.     if (descendantElement != NULL)
  693.         DisposeTwistDownElement(descendantElement);
  694.         
  695.     twistDownElement = successorElement;
  696.     }
  697. }
  698. //----------------------------------------------------------------------------------------
  699. // TTwistDownDocument::CountVisibleElements: 
  700. //----------------------------------------------------------------------------------------
  701. #pragma segment ARes
  702. long TTwistDownDocument::CountVisibleElements(TTwistDownElement* twistDownElement)
  703. {
  704. long result = 0;
  705.  
  706. while (twistDownElement != NULL) 
  707.     {
  708.         ++result;
  709.         if (twistDownElement -> TestShowSubListFlag())
  710.             result += this -> CountVisibleElements(twistDownElement -> GetDescendantElement());
  711.             
  712.         twistDownElement = twistDownElement -> GetSuccessorElement();
  713.     }    
  714.     
  715. return result;
  716.  
  717. }
  718. //----------------------------------------------------------------------------------------
  719. // TTwistDownDocument::GetTwistDownElementAt: 
  720. //----------------------------------------------------------------------------------------
  721. #pragma segment ARes
  722. void TTwistDownDocument::GetTwistDownElementAt(short anItem, TTwistDownElement* startingTwistDownElement, 
  723.                                                             TTwistDownElement** currentTwistDownElement, short &rowNumber)
  724. {
  725. MAVolatileInit(TTwistDownElement*, twistDownElement, NULL);
  726.  
  727. twistDownElement = startingTwistDownElement;
  728.  
  729. while (twistDownElement != NULL && rowNumber != anItem) 
  730.     {
  731.         ++rowNumber;
  732.         *currentTwistDownElement = twistDownElement;
  733.             
  734.         if (twistDownElement -> TestShowSubListFlag())
  735.             {
  736.                 this -> GetTwistDownElementAt(anItem, twistDownElement -> GetDescendantElement(), 
  737.                                                                             currentTwistDownElement, rowNumber);
  738.         
  739.             }
  740.         twistDownElement = twistDownElement -> GetSuccessorElement();
  741.     }    
  742.  
  743. }
  744. //----------------------------------------------------------------------------------------
  745. // TTwistDownDocument::GetTwistDownElementRowNumber: 
  746. //----------------------------------------------------------------------------------------
  747. #pragma segment ARes
  748. void TTwistDownDocument::GetTwistDownElementRowNumber(TTwistDownElement* startingTwistDownElement, 
  749.                                                             TTwistDownElement* targetTwistDownElement,
  750.                                                             TTwistDownElement** currentTwistDownElement, short &rowNumber)
  751. {
  752. MAVolatileInit(TTwistDownElement*, twistDownElement, NULL);
  753.  
  754. twistDownElement = startingTwistDownElement;
  755.  
  756. while (twistDownElement != NULL && *currentTwistDownElement != targetTwistDownElement) 
  757.     {
  758.         ++rowNumber;
  759.         *currentTwistDownElement = twistDownElement;
  760.             
  761.         if (twistDownElement -> TestShowSubListFlag())
  762.             {
  763.                 this -> GetTwistDownElementRowNumber(twistDownElement -> GetDescendantElement(), targetTwistDownElement,
  764.                                                                             currentTwistDownElement, rowNumber);
  765.         
  766.             }
  767.         twistDownElement = twistDownElement -> GetSuccessorElement();
  768.     }    
  769.  
  770. }
  771. //----------------------------------------------------------------------------------------
  772. // TTwistDownDocument::GetHeadOfList: 
  773. //----------------------------------------------------------------------------------------
  774. #pragma segment ARes
  775. TTwistDownElement* TTwistDownDocument::GetHeadOfList()
  776. {
  777. return fHeadOfListElement;
  778. }
  779. //----------------------------------------------------------------------------------------
  780. // TTwistDownDocument::ExpandElement: 
  781. //----------------------------------------------------------------------------------------
  782. #pragma segment ARes
  783. void TTwistDownDocument::ExpandElement(TTwistDownElement* twistDownElementToExpand)
  784. {
  785. OSErr myOSErr = noErr; //passed by reference to AddTwistDownControls.
  786. TTwistDownElement* currentTwistDownElement = NULL;
  787. short targetRowNumber = 0;
  788. short rowNumber = 0;
  789.  
  790. rowNumber = 0;
  791. this -> GetTwistDownElementRowNumber(fHeadOfListElement, twistDownElementToExpand, 
  792.                                                                                                         ¤tTwistDownElement, rowNumber);
  793.  
  794. targetRowNumber = rowNumber + 1;    //I want to insert rows in front of the row following the twistDownElementToExpand.
  795.                                                                     //targetRowNumber may 'point' to a row that doesn't exist. For example, the row
  796.                                                                     //following the last twistDownElement. I let BuildVisibleList take care of 
  797.                                                                     //this situation.
  798.                                                         
  799. twistDownElementToExpand -> SetShowSubListFlag();
  800.  
  801. FailInfo fi;
  802. Try(fi)
  803.     {
  804.         rowNumber = 0;
  805.         fTwistDownView -> AddTwistDownControls(fHeadOfListElement, rowNumber, myOSErr);    //This puts in the new controls 
  806.                                                                                                                                                                         //with the proper locations.
  807.  
  808.         if (myOSErr != noErr)
  809.             Failure(myOSErr, 0);
  810.                     
  811.         rowNumber = 0;
  812.         fTwistDownView -> UpdateTwistDownControlLocations(fHeadOfListElement, rowNumber); //This updates the locations 
  813.                                                                                                                                                                             //of all the controls.
  814.                                                                                                                                 
  815.         myOSErr = fTwistDownView -> BuildVisibleList(targetRowNumber);    //Inserts rows as required in front of 
  816.                                                                                                                                         //targetRowNumber unless it is beyond the end 
  817.                                                                                                                                         //of the currently displayed list. In that
  818.                                                                                                                                         //case, the rows are inserted last.
  819.  
  820.         //Ordinarily, I would test myOSErr to make sure we hadn't failed because we attempted to add
  821.         //too many rows to TTwistDownView. However, we always call TTwistDownElement::CouldExpandElement()
  822.         //in either TTwistDownControl::DoMouseUp or TTwistDownElement::DoScriptCommand and if too many
  823.         //rows would be added, we fail there rather than letting the operation get this far. The only
  824.         //failure that can occur in this method is an out of memory condition while adding new TTwistDownControls.
  825.         //if (myOSErr == errTooManyRows)
  826.         //    Failure(errTooManyRows, msgTooManyRows);
  827.         
  828.         fTwistDownView -> ResizeTwistDownViewRows();    //Adjusts the size of the view to accomodate the exact number of rows.
  829.         fi.Success();
  830.     }
  831. else
  832.     {
  833.         twistDownElementToExpand -> ClearShowSubListFlag();
  834.         TTwistDownElement* descendantTwistDownElement = twistDownElementToExpand -> GetDescendantElement();
  835.         fTwistDownView -> DeleteTwistDownControls(descendantTwistDownElement);
  836.         fi.ReSignal();
  837.     }
  838. }    //TTwistDownDocument::ExpandElement
  839. //----------------------------------------------------------------------------------------
  840. // TTwistDownDocument::CollapseElement: 
  841. //----------------------------------------------------------------------------------------
  842. #pragma segment ARes
  843. void TTwistDownDocument::CollapseElement(TTwistDownElement* twistDownElementToCollapse)
  844. {
  845. OSErr myOSErr = noErr;
  846. TTwistDownElement* descendantTwistDownElement = NULL;
  847. TTwistDownElement* currentTwistDownElement = NULL;
  848. short targetRowNumber = 0;
  849. short rowNumber = 0;
  850.  
  851. rowNumber = 0;
  852. this -> GetTwistDownElementRowNumber(fHeadOfListElement, twistDownElementToCollapse, 
  853.                                                                                                             ¤tTwistDownElement, rowNumber);
  854. targetRowNumber = rowNumber + 1;
  855.  
  856. descendantTwistDownElement = twistDownElementToCollapse -> GetDescendantElement();
  857. fTwistDownView -> DeleteTwistDownControls(descendantTwistDownElement);
  858.     
  859. twistDownElementToCollapse -> ClearShowSubListFlag();
  860.  
  861. rowNumber = 0;
  862. fTwistDownView -> UpdateTwistDownControlLocations(fHeadOfListElement, rowNumber);
  863.  
  864. myOSErr = fTwistDownView -> BuildVisibleList(targetRowNumber);     //myOSErr isn't tested because
  865.                                                                                                                                 //a tooManyRows error should
  866.                                                                                                                                 //have been caught before we
  867.                                                                                                                                 //ever get here.
  868. fTwistDownView -> ResizeTwistDownViewRows();
  869.  
  870. }    //TTwistDownDocument::CollapseElement: 
  871. //----------------------------------------------------------------------------------------
  872. // TTwistDownDocument::SetShowSubListFlags: Used by ExpandAll    
  873. //----------------------------------------------------------------------------------------
  874. #pragma segment ARes
  875. //When the Expand All command is executed, all fShowSubList flags of all twistDownElements
  876. //are set to TRUE.
  877. void TTwistDownDocument::SetShowSubListFlags(TTwistDownElement* twistDownElement)
  878. {
  879.     while (twistDownElement != NULL) 
  880.         {
  881.             if (twistDownElement -> TestHasSubListFlag())    //Only select those twistDownElements
  882.                                                                                                         //that have a sublist (have a descendant element)
  883.                 {
  884.                     twistDownElement -> SetShowSubListFlag();    //This sets fOldShowSubList to the current
  885.                                                                                                         //value of fShowSubList and then sets
  886.                                                                                                         //fShowSubList to TRUE.
  887.                                                                                                         
  888.                     this -> SetShowSubListFlags(twistDownElement -> GetDescendantElement());
  889.                 }
  890.                 
  891.             twistDownElement = twistDownElement -> GetSuccessorElement();
  892.         }    
  893. }
  894. //----------------------------------------------------------------------------------------
  895. // TTwistDownDocument::ClearShowSubListFlags: Used by CollapseAll    
  896. //----------------------------------------------------------------------------------------
  897. #pragma segment ARes
  898. //When the Collapse All command is executed, the fShowSubList flag of all twistDownElements
  899. //is set to FALSE. At present, fOldShowSublist is set to the current value of fShowSubList
  900. //before fShowSubList is set to FALSE. I probably should set fOldShowSubList to FALSE.
  901.  
  902. void TTwistDownDocument::ClearShowSubListFlags(TTwistDownElement* twistDownElement)
  903. {
  904.     while (twistDownElement != NULL) 
  905.         {
  906.             if (twistDownElement -> TestHasSubListFlag())    //Only select those twistDownElements
  907.                                                                                                         //that have a sublist (have a descendant element)
  908.                 {
  909.                     twistDownElement -> ClearShowSubListFlag();    
  910.                     this -> ClearShowSubListFlags(twistDownElement -> GetDescendantElement());
  911.                 }
  912.                 
  913.             twistDownElement = twistDownElement -> GetSuccessorElement();
  914.         }    
  915. }
  916. //----------------------------------------------------------------------------------------
  917. // TTwistDownDocument::RestoreShowSubListFlags: Used to recover from a failed ExpandAll    
  918. //----------------------------------------------------------------------------------------
  919. #pragma segment ARes
  920. //If the execution of ExpandAll should fail (out of memory), we must recover. To do that
  921. //we must restore the value of fShowSubList to its previous value. This method restores
  922. // fShowSubList to the value of fOldShowSublist and then sets fOldShowSubList to FALSE.
  923.  
  924. void TTwistDownDocument::RestoreShowSubListFlags(TTwistDownElement* twistDownElement)
  925. {
  926.     while (twistDownElement != NULL) 
  927.         {
  928.             if (twistDownElement -> TestHasSubListFlag())
  929.                 {
  930.                     twistDownElement -> RestoreShowSubListFlag();    
  931.                     this -> RestoreShowSubListFlags(twistDownElement -> GetDescendantElement());
  932.                 }
  933.                 
  934.             twistDownElement = twistDownElement -> GetSuccessorElement();
  935.         }    
  936. }
  937. //----------------------------------------------------------------------------------------
  938. // TTwistDownDocument::CollapseAll: used by TCollapseAllCommand::DoIt    
  939. //----------------------------------------------------------------------------------------
  940. #pragma segment ARes
  941. //Note:
  942. void TTwistDownDocument::CollapseAll()
  943. {
  944. OSErr myOSErr = noErr;
  945. short rowNumber = 0;
  946.  
  947. fTwistDownView -> DeleteTwistDownControls(fHeadOfListElement);    //First delete existing controls unless
  948.                                                                                                                                 //twistDownElement -> fIndentLevel == 0.
  949.                                                                                                                                 //
  950.  
  951. this -> ClearShowSubListFlags(fHeadOfListElement);        //The controls must be deleted before the
  952.                                                                                                             //fShowSubList flags are cleared. If the
  953.                                                                                                             //flags are cleared first, DeleteTwistDownControls
  954.                                                                                                             //will not traverse the list because it uses
  955.                                                                                                             //fShowSubList to descend the hierarchy.
  956.                                                                                                             //Consequently, controls will not be deleted.
  957.  
  958. rowNumber = 0;
  959. fTwistDownView -> UpdateTwistDownControlLocations(fHeadOfListElement, rowNumber);
  960.  
  961. rowNumber = 1;
  962. myOSErr = fTwistDownView -> BuildVisibleList(rowNumber);
  963.  
  964. fTwistDownView -> ResizeTwistDownViewRows();
  965.  
  966. }    //TTwistDownDocument::CollapseAll
  967. //----------------------------------------------------------------------------------------
  968. // TTwistDownDocument::InstallTextStyle: 
  969. //----------------------------------------------------------------------------------------
  970. #pragma segment ADoCommand
  971. void TTwistDownDocument::InstallTextStyle(const TextStyle& itsTextStyle)
  972. {
  973. fTextStyle = itsTextStyle;
  974. }
  975. //----------------------------------------------------------------------------------------
  976. // TTwistDownDocument::UpdateTwistDownElements: called by TTwistDownView::DoChangeWritingDirection
  977. //                                                                                                                TTwistDownView::DoChangeTextStyle
  978. //----------------------------------------------------------------------------------------
  979. #pragma segment ARes
  980. void TTwistDownDocument::UpdateTwistDownElements(TTwistDownElement* twistDownElement, short &rowNumber)
  981. {
  982.  
  983. while (twistDownElement != NULL) 
  984.     {
  985.         ++rowNumber;
  986.         TTwistDownControl* twistDownControl = twistDownElement -> GetTwistDownControl();
  987.         if (twistDownControl != NULL)
  988.             {
  989.                 twistDownControl -> InstallTextStyle(fTextStyle, kDontRedraw);    //In another time and place it
  990.                                                                                                                                                 //might be necessary that the
  991.                                                                                                                                                 //proper TextStyle be installed so
  992.                                                                                                                                                 //just do it so you don't forget
  993.                                                                                                                                                 //about it.
  994.                 twistDownControl -> UpdateControlSizeTo();        //sets fSize of twistDownControl
  995.                 twistDownControl -> UpdateControlLocationTo(rowNumber);    //sets fCoordinatesAreInvalid
  996.  
  997.             }
  998.             
  999.         if (twistDownElement -> TestShowSubListFlag())
  1000.             this -> UpdateTwistDownElements(twistDownElement -> GetDescendantElement(), rowNumber);
  1001.             
  1002.         twistDownElement = twistDownElement -> GetSuccessorElement();
  1003.     }    
  1004.  
  1005. }
  1006. //----------------------------------------------------------------------------------------
  1007. // TTwistDownDocument::CalculateColWidthParams: called by TTwistDownView::CalculateColumnWidth
  1008. //----------------------------------------------------------------------------------------
  1009. //This routine scans the visible list and returns the greatest value for the indentLevel it
  1010. //finds along with the width of the largest twistDownElement -> fDisplayedText. The intent
  1011. //is to use that information to intelligently set the column width in the twistDownView.
  1012. //It has been tested but is not currently being used.
  1013. #pragma segment ARes
  1014. void TTwistDownDocument::CalculateColWidthParams(TTwistDownElement* twistDownElement, short& maxIndentLevel, 
  1015.                                                                                                                             short& maxTextWidth)                     
  1016. {
  1017. while (twistDownElement != NULL) 
  1018.     {
  1019.         short indentLevel = twistDownElement -> GetIndentLevel();
  1020.         if (indentLevel > maxIndentLevel)
  1021.             maxIndentLevel = indentLevel;
  1022.         
  1023.         CStr63    displayedText = gEmptyString;
  1024.         twistDownElement -> GetDisplayedText(displayedText);
  1025.         short stringWidth = StringWidth(displayedText);
  1026.         if (stringWidth > maxTextWidth)
  1027.             maxTextWidth = stringWidth;
  1028.             
  1029.         if (twistDownElement -> TestShowSubListFlag())
  1030.             this -> CalculateColWidthParams(twistDownElement -> GetDescendantElement(), maxIndentLevel, maxTextWidth);
  1031.             
  1032.         twistDownElement = twistDownElement -> GetSuccessorElement();
  1033.     }    
  1034. }
  1035. //----------------------------------------------------------------------------------------
  1036. // TTwistDownDocument::IncrementItemsInList: 
  1037. //----------------------------------------------------------------------------------------
  1038. #pragma segment AOpen
  1039. void  TTwistDownDocument::IncrementItemsInList()
  1040. {
  1041. fNumberOfItemsInList++;
  1042. }
  1043. //----------------------------------------------------------------------------------------
  1044. // TTwistDownDocument::DecrementItemsInList: 
  1045. //----------------------------------------------------------------------------------------
  1046. #pragma segment AClose
  1047. void  TTwistDownDocument::DecrementItemsInList()
  1048. {
  1049. fNumberOfItemsInList--;
  1050. }
  1051. //----------------------------------------------------------------------------------------
  1052. // TTwistDownDocument::GetNumberOfDirectoriesInList: 
  1053. //----------------------------------------------------------------------------------------
  1054. #pragma segment ARes
  1055. long TTwistDownDocument::GetNumberOfDirectoriesInList()
  1056. {
  1057. return fNumberOfDirectoriesInList;
  1058. }
  1059. //----------------------------------------------------------------------------------------
  1060. // TTwistDownDocument::GetNumberOfItemsInList: 
  1061. //----------------------------------------------------------------------------------------
  1062. #pragma segment ARes
  1063. long TTwistDownDocument::GetNumberOfItemsInList()
  1064. {
  1065. return fNumberOfItemsInList;
  1066. }
  1067. //----------------------------------------------------------------------------------------
  1068. // TTwistDownDocument::DoScriptCommand:    Scripting Support    
  1069. //----------------------------------------------------------------------------------------
  1070. #pragma segment MAScriptingRes
  1071. void TTwistDownDocument::DoScriptCommand(CommandNumber aCommandNumber, TAppleEvent* message, TAppleEvent* reply)
  1072. {
  1073.  
  1074. switch (aCommandNumber)
  1075.     {
  1076.         case cExpandAll:
  1077.             {
  1078.             //If fCouldExpandAll == TRUE then we most certainly will not be adding too many rows.
  1079.             //However, TExpandAllCommand::DoIt also checks - overkill???
  1080.                 if (fTwistDownView -> fCouldExpandAll) 
  1081.                     {
  1082.                         long objectHeapSpaceRequired = long((this -> GetNumberOfDirectoriesInList() 
  1083.                                                             - fTwistDownView -> GetNumberOfControls())*(gTwistDownApp -> fTDControlClassSize));
  1084.                                                                                     
  1085.                         Boolean haveHeapSpace = HaveObjectHeapSpace(objectHeapSpaceRequired + 3*1024);
  1086.  
  1087.                         if (haveHeapSpace)
  1088.                             {
  1089.                                 TExpandAllCommand* anExpandAllCommand = new TExpandAllCommand;
  1090.                                 anExpandAllCommand -> IExpandAllCommand(this,fTwistDownView, 
  1091.                                                                                                                 message -> fMessage, reply -> fMessage);
  1092.                                 
  1093.                                 this -> PostCommand(anExpandAllCommand);                            
  1094.                             }
  1095.                         else
  1096.                             Failure(memFullErr, 0);                        
  1097.                     }
  1098.                 else
  1099.                     FailOSErr(errListAlreadyExpanded);
  1100.             }
  1101.             break;
  1102.             
  1103.         case cCollapseAll:
  1104.             {
  1105.                 if (fTwistDownView -> fCouldCollapseAll)
  1106.                     {
  1107.                     //Because we don't want this to fail for out of memory reasons,
  1108.                     //allocate it from temporary memory.    //PGMacApp 550
  1109.                         Boolean oldTemp = TemporaryAllocation(TRUE);
  1110.                         Boolean oldArrayPerm = AllocateObjectsFromPerm(FALSE);
  1111.                             TCollapseAllCommand* aCollapseAllCommand = new TCollapseAllCommand;
  1112.                             aCollapseAllCommand -> ICollapseAllCommand(this, fTwistDownView, 
  1113.                                                                                                                 message -> fMessage, reply -> fMessage);                            
  1114.                             
  1115.                             this -> PostCommand(aCollapseAllCommand);
  1116.                         oldArrayPerm = AllocateObjectsFromPerm(oldArrayPerm);    
  1117.                         oldTemp = TemporaryAllocation(oldTemp);
  1118.                     }
  1119.                 else
  1120.                     FailOSErr(errListAlreadyCollapsed);
  1121.             }
  1122.             break;
  1123.                 
  1124.         default:
  1125.             {        
  1126.             Inherited::DoScriptCommand(aCommandNumber, message, reply);
  1127.             }
  1128.             break;
  1129.     }
  1130.  
  1131. }
  1132. //----------------------------------------------------------------------------------------
  1133. //Note: The following four methods:
  1134. //
  1135. //GetTwistDownElementByName,
  1136. //GetTwistDownElementByIndex,
  1137. //GetVisibleTwistDownElementByName, and
  1138. //GetVisibleTwistDownElementByIndex
  1139. //
  1140. //would not exist if Scripting were not supported. Each twistDownElement in the list has
  1141. //an absolute position established when the list is read. However, the whole list is not
  1142. //always visible to the user. Now, if a user were to expand a twistDownElement that is not
  1143. //visible, the view would not change and he might be expecting a change. This could cause
  1144. //confusion. One solution would be to make it visible by expanding all the twistDownElements
  1145. //in the chain above the target twistDownElement. At this point, I don't like that idea.
  1146. //The solution chosen here, is to allow the user to specify a search method of either just 
  1147. //the visible list or the whole list. The default is to search only the visible list.
  1148. //
  1149. //If the user chooses to search the whole list, when expanding or collapsing a twistDownElement,
  1150. //and the twistDownElement is not visible, the expansion or collapse of the element takes
  1151. //place but is not visible to the user at that time. However, if the user then expands
  1152. //all the elements in the chain above the target twistDownElement, the effect will then be
  1153. //seen (revealed). 
  1154. //
  1155. //This situation clearly illustrates a situation where scripting support must go beyond the
  1156. //capabilities of the user interface. In other words, it is not possible for the user to
  1157. //expand or collapse a twistDownElement that is not visible from the user interface.
  1158. //----------------------------------------------------------------------------------------
  1159. // TTwistDownDocument::GetTwistDownElementByName:        Scripting Support    
  1160. //----------------------------------------------------------------------------------------
  1161. #pragma segment ARes
  1162. void TTwistDownDocument::GetTwistDownElementByName(TTwistDownElement* startingTwistDownElement, 
  1163.                                                             TTwistDownElement** currentTwistDownElement, CStr63 &theName, Boolean &foundIt)
  1164. {
  1165. MAVolatileInit(TTwistDownElement*, twistDownElement, NULL);
  1166.  
  1167. twistDownElement = startingTwistDownElement;
  1168.  
  1169. while (twistDownElement != NULL && foundIt == FALSE) 
  1170.     {
  1171.         
  1172.         *currentTwistDownElement = twistDownElement;
  1173.         CStr63 aString = gEmptyString;
  1174.         twistDownElement -> GetDisplayedText(aString);
  1175.         if (aString == theName)
  1176.             foundIt = TRUE;
  1177.             
  1178.         if (twistDownElement -> GetDescendantElement() != NULL)
  1179.             this -> GetTwistDownElementByName(twistDownElement -> GetDescendantElement(), currentTwistDownElement, 
  1180.                                                                                                                             theName, foundIt);
  1181.         
  1182.         twistDownElement = twistDownElement -> GetSuccessorElement();
  1183.     }    
  1184.  
  1185. }
  1186. //----------------------------------------------------------------------------------------
  1187. // TTwistDownDocument::GetTwistDownElementByIndex:        Scripting Support    
  1188. //----------------------------------------------------------------------------------------
  1189. #pragma segment ARes
  1190. void TTwistDownDocument::GetTwistDownElementByIndex(short desiredIndex, 
  1191.                                                             TTwistDownElement* startingTwistDownElement, 
  1192.                                                             TTwistDownElement** currentTwistDownElement, 
  1193.                                                             short &elementCounter)
  1194. {
  1195. MAVolatileInit(TTwistDownElement*, twistDownElement, NULL);
  1196.  
  1197. twistDownElement = startingTwistDownElement;
  1198.  
  1199. while (twistDownElement != NULL && elementCounter != desiredIndex) 
  1200.     {
  1201.         ++elementCounter;
  1202.         *currentTwistDownElement = twistDownElement;
  1203.             
  1204.         if (twistDownElement -> GetDescendantElement() != NULL)
  1205.             this -> GetTwistDownElementByIndex(desiredIndex, twistDownElement -> GetDescendantElement(), 
  1206.                                                                             currentTwistDownElement, elementCounter);
  1207.         
  1208.         twistDownElement = twistDownElement -> GetSuccessorElement();
  1209.     }    
  1210.  
  1211. }
  1212. //----------------------------------------------------------------------------------------
  1213. // TTwistDownDocument::GetVisibleTwistDownElementByName:        Scripting Support    
  1214. //----------------------------------------------------------------------------------------
  1215. #pragma segment ARes
  1216. void TTwistDownDocument::GetVisibleTwistDownElementByName(TTwistDownElement* startingTwistDownElement, 
  1217.                                                             TTwistDownElement** currentTwistDownElement, CStr63 &theName, Boolean &foundIt)
  1218. {
  1219. MAVolatileInit(TTwistDownElement*, twistDownElement, NULL);
  1220.  
  1221. twistDownElement = startingTwistDownElement;
  1222.  
  1223. while (twistDownElement != NULL && foundIt == FALSE) 
  1224.     {
  1225.         
  1226.         *currentTwistDownElement = twistDownElement;
  1227.         CStr63 aString = gEmptyString;
  1228.         twistDownElement -> GetDisplayedText(aString);
  1229.         if (aString == theName)
  1230.             foundIt = TRUE;
  1231.             
  1232.         if (twistDownElement -> GetDescendantElement() != NULL && twistDownElement -> TestShowSubListFlag())
  1233.             this -> GetVisibleTwistDownElementByName(twistDownElement -> GetDescendantElement(), currentTwistDownElement, 
  1234.                                                                                                                             theName, foundIt);
  1235.         
  1236.         twistDownElement = twistDownElement -> GetSuccessorElement();
  1237.     }    
  1238.  
  1239. }
  1240. //----------------------------------------------------------------------------------------
  1241. // TTwistDownDocument::GetVisibleTwistDownElementByIndex:        Scripting Support    
  1242. //----------------------------------------------------------------------------------------
  1243. #pragma segment ARes
  1244. void TTwistDownDocument::GetVisibleTwistDownElementByIndex(short desiredIndex, TTwistDownElement* startingTwistDownElement, 
  1245.                                                             TTwistDownElement** currentTwistDownElement, short &elementCounter)
  1246. {
  1247. MAVolatileInit(TTwistDownElement*, twistDownElement, NULL);
  1248.  
  1249. twistDownElement = startingTwistDownElement;
  1250.  
  1251. while (twistDownElement != NULL && elementCounter != desiredIndex) 
  1252.     {
  1253.         ++elementCounter;
  1254.         *currentTwistDownElement = twistDownElement;
  1255.             
  1256.         if (twistDownElement -> GetDescendantElement() != NULL && twistDownElement -> TestShowSubListFlag())
  1257.             this -> GetVisibleTwistDownElementByIndex(desiredIndex, twistDownElement -> GetDescendantElement(), 
  1258.                                                                             currentTwistDownElement, elementCounter);
  1259.         
  1260.         twistDownElement = twistDownElement -> GetSuccessorElement();
  1261.     }    
  1262.  
  1263. }
  1264. //----------------------------------------------------------------------------------------
  1265. // TTwistDownDocument::GetObjectProperty:        Scripting Support
  1266. //----------------------------------------------------------------------------------------
  1267. #pragma segment MAScriptingRes
  1268.  
  1269. Boolean TTwistDownDocument::GetObjectProperty(CAEDesc& thePropertyValue,
  1270.                                         DescType whichProperty,
  1271.                                         const CAEDesc& desiredType)
  1272. {
  1273.     // Return properties for the twistDownView
  1274.     
  1275.     Boolean hasProperty = TRUE;
  1276.     
  1277.     FailInfo fi;
  1278.     Try(fi)
  1279.     {
  1280.         switch (whichProperty)
  1281.         {
  1282.  
  1283.             case pFontName:
  1284.                 CStr255 theFontName;
  1285.                 short theFontNum = fTextStyle.tsFont;
  1286.                 GetFontName(theFontNum, theFontName);
  1287.                 thePropertyValue.PutString(theFontName);
  1288.                 break;
  1289.                 
  1290.             case pPointSize:
  1291.                 long itsSize = (long)fTextStyle.tsSize;    
  1292.                 thePropertyValue.PutLong(itsSize);
  1293.                 break;                
  1294.  
  1295.             case pSearchMethod:
  1296.                 {
  1297.                     DescType theSearchMethod;
  1298.                     
  1299.                     if (fSearchMethod == visibleList)
  1300.                         theSearchMethod = kAEVisibleList;
  1301.                     else
  1302.                         theSearchMethod = kAEWholeList;
  1303.                         
  1304.                     thePropertyValue.PutEnum(theSearchMethod);
  1305.                 }
  1306.                 break;    
  1307.             
  1308.             case pNumFolders:
  1309.                     thePropertyValue.PutLong(fNumberOfDirectoriesInList);
  1310.                 break;    
  1311.                 
  1312.             case pNumFiles:
  1313.                     thePropertyValue.PutLong(fNumberOfFilesInList);
  1314.                 break;    
  1315.  
  1316.             case pNumItems:
  1317.                     thePropertyValue.PutLong(fNumberOfItemsInList);
  1318.                 break;
  1319.  
  1320.             default:
  1321.                 hasProperty = Inherited::GetObjectProperty(thePropertyValue, whichProperty, desiredType);
  1322.                 break;
  1323.         }
  1324.         fi.Success();
  1325.     }
  1326.     else
  1327.     {
  1328.         // we failed while trying to get the property
  1329.         hasProperty = FALSE;
  1330.         
  1331.         // Don't ReSignal
  1332.     }
  1333.     return hasProperty;
  1334. }
  1335. //----------------------------------------------------------------------------------------
  1336. // TTwistDownDocument::GetSetPropertyInfo:        Scripting Support
  1337. //----------------------------------------------------------------------------------------
  1338. #pragma segment MAScriptingRes
  1339. void TTwistDownDocument::GetSetPropertyInfo(DescType whichProperty,CommandNumber& cmdNum,
  1340.                                 Boolean& canUndo,Boolean& causesChange,TCommandHandler* &theContext)
  1341. {
  1342.  
  1343. switch(whichProperty)
  1344.     {
  1345.     
  1346.         case pFontName:
  1347.             cmdNum = cChangeFont;
  1348.             canUndo = FALSE;
  1349.             causesChange = FALSE;
  1350.             theContext = this;
  1351.             break;
  1352.             
  1353.         case pPointSize:
  1354.             cmdNum = cChangeFontSize;
  1355.             canUndo = FALSE;
  1356.             causesChange = FALSE;
  1357.             theContext = this;
  1358.             break;
  1359.  
  1360.         case pSearchMethod:
  1361.             cmdNum = cSetSearchMethod;
  1362.             canUndo = FALSE;
  1363.             causesChange = FALSE;
  1364.             theContext = this;
  1365.             break;
  1366.         
  1367.         default:
  1368.             Inherited::GetSetPropertyInfo(whichProperty, cmdNum, canUndo, causesChange, theContext);
  1369.             break;
  1370.     }
  1371. }
  1372. //----------------------------------------------------------------------------------------
  1373. // TTwistDownDocument::SetObjectProperty:        Scripting Support
  1374. //----------------------------------------------------------------------------------------
  1375. #pragma segment MAScriptingRes
  1376. void TTwistDownDocument::SetObjectProperty(const CAEDesc& thePropertyValue,DescType whichProperty)
  1377. {
  1378. //I'm ambivalent about whether it makes sense to allow a script to change the font or its size,
  1379. //if the list is empty. We wouldn't allow it from the menu. For the sake of argument, let's
  1380. //allow it here and not allow it in TTwistDownView::SetObjectProperty.
  1381.  
  1382. long numberOfItemsInList = numberOfItemsInList = this -> GetNumberOfItemsInList();
  1383.     
  1384. switch (whichProperty)
  1385.     {
  1386.  
  1387.             case pFontName:
  1388.                 CStr255 newFontName;
  1389.                 thePropertyValue.GetString(newFontName,255);
  1390. //                if (numberOfItemsInList > 0)
  1391.                     fTwistDownView -> DoChangeFont(newFontName);
  1392.                 break;
  1393.                 
  1394.             case pPointSize:
  1395.                 short newFontSize = 0;    
  1396.                 newFontSize = (short)thePropertyValue.GetLong();
  1397. //                if (numberOfItemsInList > 0)
  1398.                     fTwistDownView -> DoChangeFontSize(newFontSize);
  1399.                 break;                
  1400.  
  1401.             case pSearchMethod:
  1402.                 {
  1403.                     DescType theSearchMethod = thePropertyValue.GetEnum();
  1404.                     
  1405.                     if (theSearchMethod == kAEVisibleList)
  1406.                         fSearchMethod = visibleList;
  1407.                     else
  1408.                         fSearchMethod = wholeList;
  1409.                 }
  1410.                 break;    
  1411.                 
  1412.             case pNumFolders:
  1413.             case pNumFiles:
  1414.             case pNumItems:
  1415.                     FailOSErr(errAECantSetReadOnly);
  1416.                 break;
  1417.  
  1418.         default:
  1419.             Inherited::SetObjectProperty(thePropertyValue, whichProperty);
  1420.             break;
  1421.     }
  1422. }
  1423. //----------------------------------------------------------------------------------------
  1424. // TTwistDownDocument::GetIndContainedObject:    Scripting Support
  1425. //----------------------------------------------------------------------------------------
  1426. #pragma segment OSLDispatchRes
  1427.  
  1428. MScriptableObject* TTwistDownDocument::GetIndContainedObject(DescType desiredType,long index)
  1429. {
  1430.  
  1431.     MScriptableObject *indexedObject;
  1432.     
  1433.     switch(desiredType)
  1434.     {
  1435.         case cTwistDownView:
  1436.             {        
  1437.                 TTwistDownView* indexedTwistDownView = fTwistDownView;
  1438.                 indexedObject = indexedTwistDownView;
  1439.             }
  1440.             break;
  1441.  
  1442.         case cTwistDownElement:
  1443.             {
  1444.             
  1445.  
  1446.                 TTwistDownElement* currentTwistDownElement = NULL;
  1447.                 short theIndex = (short)index;
  1448.                 short elementCounter = 0;
  1449.                 
  1450.                 if (fSearchMethod == visibleList)
  1451.                     this -> GetVisibleTwistDownElementByIndex(theIndex, fHeadOfListElement, 
  1452.                                                                                                                 ¤tTwistDownElement, elementCounter);
  1453.                 else
  1454.             //Note: I should be able to do this using the fItemInList field of TTwistDownElement
  1455.             //instead of counting.                
  1456.                     this -> GetTwistDownElementByIndex(theIndex, fHeadOfListElement, 
  1457.                                                                                                                 ¤tTwistDownElement, elementCounter);
  1458.                 
  1459.                 indexedObject = currentTwistDownElement;
  1460.             }
  1461.             break;
  1462.             
  1463.         default:
  1464.             {
  1465.                 indexedObject = Inherited::GetIndContainedObject(desiredType, index);
  1466.             }
  1467.             break;
  1468.     }
  1469.     
  1470.     return indexedObject;
  1471. }
  1472. //----------------------------------------------------------------------------------------
  1473. // TTwistDownDocument::GetContainedObject:    Scripting Support
  1474. //----------------------------------------------------------------------------------------
  1475. #pragma segment OSLDispatchRes
  1476. MScriptableObject* TTwistDownDocument::GetContainedObject(DescType desiredType,DescType selectionForm,
  1477.                                                                                                                                     const CAEDesc& selectionData)
  1478. {    
  1479.  
  1480.     MScriptableObject * result = NULL;
  1481.     
  1482.     if (desiredType == cTwistDownView)
  1483.         {        
  1484.             TTwistDownView* resultTwistDownView = fTwistDownView;
  1485.             result = resultTwistDownView;
  1486.         }
  1487.         
  1488.     else if (desiredType == cTwistDownElement)
  1489.         {
  1490.         
  1491.             if (selectionForm == formName)
  1492.                 {
  1493.                     CStr255 theName = gEmptyString;
  1494.                     selectionData.GetString(theName);
  1495.                     TTwistDownElement* currentTwistDownElement = NULL;
  1496.                     Boolean foundIt = FALSE;
  1497.                     
  1498.                     if (fSearchMethod == visibleList)
  1499.                         this -> GetVisibleTwistDownElementByName(fHeadOfListElement, ¤tTwistDownElement, 
  1500.                                                                                                                                                 (CStr63 &)theName, foundIt);
  1501.                     else
  1502.                         this -> GetTwistDownElementByName(fHeadOfListElement, ¤tTwistDownElement, 
  1503.                                                                                                                                                 (CStr63 &)theName, foundIt);
  1504.  
  1505.                     if (foundIt == FALSE)
  1506.                         currentTwistDownElement = NULL;
  1507.  
  1508.                     result = currentTwistDownElement;
  1509.                 }
  1510.             else if (selectionForm == formAbsolutePosition)
  1511.                 {
  1512.                     //Note: I should be able to do this using the fItemInList field of TTwistDownElement
  1513.                     //instead of counting.
  1514.                     TTwistDownElement* currentTwistDownElement = NULL;
  1515.                     long index = selectionData.GetLong();
  1516.                     short theIndex = (short)index;
  1517.                     
  1518.                     if (theIndex <= fNumberOfItemsInList)
  1519.                         {
  1520.                             short elementCounter = 0;
  1521.                             
  1522.                             if (fSearchMethod == visibleList)
  1523.                                 this -> GetVisibleTwistDownElementByIndex(theIndex, fHeadOfListElement, 
  1524.                                                                                                                                 ¤tTwistDownElement, elementCounter);                                                    
  1525.                             else
  1526.                                 this -> GetTwistDownElementByIndex(theIndex, fHeadOfListElement, 
  1527.                                                                                                                                 ¤tTwistDownElement, elementCounter);
  1528.                         }
  1529.                         
  1530.                     result = currentTwistDownElement;        
  1531.  
  1532.                 }
  1533.         }
  1534.         
  1535.     else
  1536.         result = Inherited::GetContainedObject(desiredType, selectionForm, selectionData);
  1537.         
  1538.     return result;
  1539. }
  1540. //----------------------------------------------------------------------------------------
  1541. // TTwistDownDocument::CountContainedObjects: 
  1542. //----------------------------------------------------------------------------------------
  1543. #pragma segment MAScriptingRes
  1544.  
  1545. long TTwistDownDocument::CountContainedObjects(DescType desiredType)
  1546. {
  1547.  
  1548.     long result = 0;
  1549.  
  1550.     switch (desiredType)
  1551.     {
  1552.         case cTwistDownView:
  1553.             {
  1554.                 result = 1;
  1555.             }
  1556.             break;
  1557.  
  1558.         case cTwistDownElement:
  1559.             {
  1560.                 result = fNumberOfItemsInList;
  1561.             }
  1562.             break;
  1563.  
  1564.         default:
  1565.             {        
  1566.                 result = Inherited::CountContainedObjects(desiredType);
  1567.             }
  1568.             break;
  1569.     }
  1570.  
  1571.     return result;
  1572. }
  1573. //========================================================================================
  1574. // CLASS TExpandAllCommand    
  1575. //========================================================================================
  1576. #undef Inherited
  1577. #define Inherited TServerCommand
  1578.  
  1579. #pragma segment ARes
  1580. MA_DEFINE_CLASS_M1(TExpandAllCommand, Inherited);
  1581. //----------------------------------------------------------------------------------------
  1582. // TExpandAllCommand::TExpandAllCommand: 
  1583. //----------------------------------------------------------------------------------------
  1584. #pragma segment ARes
  1585. TExpandAllCommand::TExpandAllCommand()
  1586. {
  1587. fTwistDownView = NULL;
  1588. fTwistDownDocument = NULL;
  1589.  
  1590. fOldNumberOfExpandedControls = 0;
  1591. fOldNumberOfCollapsedControls = 0;
  1592.  
  1593. #if qDebug
  1594. this -> PrintAppConstructorClassInfo();
  1595. #endif
  1596. }
  1597. //----------------------------------------------------------------------------------------
  1598. // TExpandAllCommand::~TExpandAllCommand: 
  1599. //----------------------------------------------------------------------------------------
  1600. #pragma segment ARes
  1601. TExpandAllCommand::~TExpandAllCommand()
  1602. {
  1603.  
  1604. fTwistDownView = NULL;
  1605. fTwistDownDocument = NULL;
  1606.  
  1607. fOldNumberOfExpandedControls = 0;
  1608. fOldNumberOfCollapsedControls = 0;
  1609.  
  1610. #if qDebug
  1611. this -> PrintAppDestructorClassInfo();
  1612. #endif
  1613. }
  1614. //----------------------------------------------------------------------------------------
  1615. //    TExpandAllCommand::IExpandAllCommand:    
  1616. //----------------------------------------------------------------------------------------
  1617. #pragma segment ASelCommand
  1618. void TExpandAllCommand::IExpandAllCommand(TTwistDownDocument* twistDownDocument, TCommandHandler* itsContext)
  1619. {
  1620. this -> IServerCommand(cExpandAll,itsContext,kCantUndo, kDoesNotCauseChange,NULL);
  1621.  
  1622. fTwistDownDocument = twistDownDocument;
  1623. fTwistDownView = twistDownDocument -> fTwistDownView;
  1624.  
  1625. fOldNumberOfExpandedControls = fTwistDownView -> GetNumberOfExpandedControls();
  1626. fOldNumberOfCollapsedControls = fTwistDownView -> GetNumberOfCollapsedControls();
  1627.                                                         
  1628. }
  1629.  
  1630. //----------------------------------------------------------------------------------------
  1631. //    TExpandAllCommand::IExpandAllCommand:    
  1632. //----------------------------------------------------------------------------------------
  1633. #pragma segment ASelCommand
  1634. void TExpandAllCommand::IExpandAllCommand(TTwistDownDocument* twistDownDocument, TCommandHandler* itsContext, 
  1635.                                                                                     const AppleEvent& itsMessage, const AppleEvent& itsReply)
  1636. {
  1637. fSuspendTheEvent = TRUE;    //For debugging fun and games, comment this out. Everything
  1638.                                                     //will work fine until you encounter low memory conditions
  1639.                                                     //and fail. Then all bets are off. Note that it must be set
  1640.                                                     //before IServerCommand is called.
  1641.  
  1642. this -> IServerCommand(cExpandAll,itsContext,kCantUndo, kDoesNotCauseChange,NULL,itsMessage,itsReply);
  1643.  
  1644.  
  1645.                                                     
  1646. fTwistDownDocument = twistDownDocument;
  1647. fTwistDownView = twistDownDocument -> fTwistDownView;
  1648.  
  1649. fOldNumberOfExpandedControls = fTwistDownView -> GetNumberOfExpandedControls();
  1650. fOldNumberOfCollapsedControls = fTwistDownView -> GetNumberOfCollapsedControls();
  1651.  
  1652. }
  1653.  
  1654. //----------------------------------------------------------------------------------------
  1655. // TExpandAllCommand::MakeAppleEvent:        Scripting Support    
  1656. //----------------------------------------------------------------------------------------
  1657. #pragma segment ACommandRes
  1658. TAppleEvent* TExpandAllCommand::MakeAppleEvent()
  1659. {
  1660.     MAVolatileInit(TAppleEvent*, theExpandAllEvent, NULL);
  1661.     
  1662.     FailInfo fi;
  1663.         Try(fi)
  1664.         {
  1665.             theExpandAllEvent = new TAppleEvent;
  1666.             theExpandAllEvent -> IAppleEvent(kAETwistDownListsSuite, kAEExpandAllID,gServerAddress, kAENoReply);
  1667.             {
  1668.                 CTempDesc    directObjectDesc;
  1669.                 if (gAppleEventRouting == routeToDoc)
  1670.                     fTwistDownDocument -> MakeObjectSpecifier(directObjectDesc, fTwistDownDocument -> GetSpecifierForm());
  1671.                 else if (gAppleEventRouting == routeToView)
  1672.                     fTwistDownView -> MakeObjectSpecifier(directObjectDesc, fTwistDownView -> GetSpecifierForm());
  1673.     
  1674.                 theExpandAllEvent -> WriteParameter(keyDirectObject, directObjectDesc);
  1675.             }
  1676.             fi.Success();
  1677.         }
  1678.         else // Recover
  1679.         {
  1680.             theExpandAllEvent = (TAppleEvent *)FreeIfObject(theExpandAllEvent);
  1681.             fi.ReSignal();
  1682.         }
  1683.         
  1684.     return theExpandAllEvent;
  1685.     
  1686. }
  1687. //----------------------------------------------------------------------------------------
  1688. //    TExpandAllCommand::DoIt:    
  1689. //----------------------------------------------------------------------------------------
  1690. #pragma segment ADoCommand
  1691. void TExpandAllCommand::DoIt()
  1692. {
  1693. OSErr myOSErr = noErr;
  1694. TTwistDownElement* headOfListElement = fTwistDownDocument -> GetHeadOfList();
  1695. short rowNumber = 0;
  1696.  
  1697. FailInfo fi;
  1698. Try(fi)
  1699.     {
  1700. //Note: The following test is here only to support scripting. DoMenuCommand support does not
  1701. //require this test because the fCouldExpandAll flag will be FALSE if the number of items
  1702. //in the list exceeds the capacity of TTextListView. In other words, if there are too many 
  1703. //rows to display, you can't get here from the menu and you shouldn't be able to get here
  1704. //from DoScriptCommand either because DoScriptCommand tests fCouldExpandAll before even
  1705. //making the TExpandAllCommand. 
  1706.         if (fTwistDownDocument -> GetNumberOfItemsInList() <= (long)kMaxNumberOfItemsToDisplay)
  1707.             {
  1708.                 //Step 1: For all TTwistDownElements for which fHasSubList is TRUE, set fShowSubList to TRUE.
  1709.                 fTwistDownDocument -> SetShowSubListFlags(headOfListElement);    
  1710.                                                                                                                                     
  1711.                 //Step 2: Make and add the new controls to the twistDownView (with the proper locations.)    
  1712.                 rowNumber = 0;
  1713.  
  1714.                 fTwistDownView -> AddTwistDownControls(headOfListElement, rowNumber, myOSErr);                                                                                                        
  1715.  
  1716.                 if (myOSErr != noErr)
  1717.                     Failure(myOSErr, 0);
  1718.                     
  1719.                 //Step 3: Uupdate the locations of all the controls.
  1720.                 rowNumber = 0;        
  1721.                 fTwistDownView -> UpdateTwistDownControlLocations(headOfListElement, rowNumber); 
  1722.  
  1723.                 //Step 4: Insert rows as required in front of rowNumber unless it
  1724.                 //is beyond the end of the currently displayed list. In that
  1725.                 //case, the rows are inserted last.
  1726.                 rowNumber = 1;                                                                                                                                
  1727.                 myOSErr = fTwistDownView -> BuildVisibleList(rowNumber);                                                            
  1728.         
  1729.                 //Step 5: Adjust the size of the view to accomodate the exact number of rows.
  1730.                 fTwistDownView -> ResizeTwistDownViewRows();
  1731.         
  1732.                 //just set fNumberOfExpandedControls to fNumberOfDirectoriesInList
  1733.                 //and set fNumberOfCollapsedControls to 0.
  1734.                 fTwistDownView -> SetCantExpandAll();    //Will cause the cExpandAll command to be disabled.
  1735.             }
  1736.         else
  1737.             {
  1738.                 myOSErr = errTooManyRows;
  1739.                 Failure(errTooManyRows, msgTooManyRows);
  1740.             }
  1741.         
  1742.         fi.Success();
  1743.     }
  1744. else
  1745.     {    //Situation: For all twistDownElements for which fHasSubList if TRUE, fOldShowSubList
  1746.         //has been set to fShowSubList and then fShowSubList has been set to TRUE. New twistDownControls
  1747.         //may have been added to the twistDownView. If failure occurred on the first attempt
  1748.         //to AddTwistDownControls, no new twistDownControls will have been added. The failure
  1749.         //handler in AddTwistDownControls will have freed the offending control.
  1750.         //
  1751.         //To recover, we need to remove twistDownControls from from all twistDownElements 
  1752.         //whose fOldShowSubList flag is set to FALSE. Then fShowSubList must be set to the
  1753.         //value of fOldShowSubList and then fOldShowSubList must be set to FALSE.
  1754.         
  1755.         //There are two kinds of errors that bring us here. In the case of errTooManyRows, nothing
  1756.         //has been done to the list and we skip over the following steps and ReSignal. In the other case
  1757.         //An out of memory condition may be signaled by AddTwistDownControls. In that case the prior state
  1758.         //of the list must be restored.
  1759.         if (myOSErr != errTooManyRows)
  1760.             {
  1761.                 //Step 1: Remove the unwanted twistDownControls. A failure in AddTwistDownControls will have 
  1762.                 //freed the offending twistDownControl before we get here.
  1763.         
  1764.                 fTwistDownView -> RestoreTwistDownControls(headOfListElement);
  1765.         
  1766.                 //Step 2: Restore the fShowSubList flags to their previous setting and set fOldShowSubList
  1767.                 //to FALSE.
  1768.  
  1769.                 fTwistDownDocument -> RestoreShowSubListFlags(headOfListElement);
  1770.  
  1771.                 fTwistDownView -> SetNumberOfExpandedControlsTo(fOldNumberOfExpandedControls);
  1772.                 fTwistDownView -> SetNumberOfCollapsedControlsTo(fOldNumberOfCollapsedControls);
  1773.                 fTwistDownView -> SetTheCouldFlags();
  1774.             }
  1775.         fi.ReSignal();
  1776.     }
  1777. }
  1778. //========================================================================================
  1779. // CLASS TCollapseAllCommand    
  1780. //========================================================================================
  1781. #undef Inherited
  1782. #define Inherited TServerCommand
  1783.  
  1784. #pragma segment ARes
  1785. MA_DEFINE_CLASS_M1(TCollapseAllCommand, Inherited);
  1786. //----------------------------------------------------------------------------------------
  1787. // TCollapseAllCommand::TCollapseAllCommand: 
  1788. //----------------------------------------------------------------------------------------
  1789. #pragma segment ARes
  1790. TCollapseAllCommand::TCollapseAllCommand()
  1791. {
  1792. fTwistDownDocument = NULL;
  1793.  
  1794. #if qDebug
  1795. this -> PrintAppConstructorClassInfo();
  1796. #endif
  1797. }
  1798. //----------------------------------------------------------------------------------------
  1799. // TCollapseAllCommand::~TCollapseAllCommand: 
  1800. //----------------------------------------------------------------------------------------
  1801. #pragma segment ARes
  1802. TCollapseAllCommand::~TCollapseAllCommand()
  1803. {
  1804. fTwistDownDocument = NULL;
  1805. fTwistDownView = NULL;
  1806. #if qDebug
  1807. this -> PrintAppDestructorClassInfo();
  1808. #endif
  1809. }
  1810. //----------------------------------------------------------------------------------------
  1811. //    TCollapseAllCommand::ICollapseAllCommand:    
  1812. //----------------------------------------------------------------------------------------
  1813. #pragma segment ASelCommand
  1814. void TCollapseAllCommand::ICollapseAllCommand(TTwistDownDocument* twistDownDocument, TCommandHandler* itsContext)
  1815. {
  1816. this -> IServerCommand(cCollapseAll,itsContext,kCantUndo, kDoesNotCauseChange,NULL);
  1817.  
  1818. fTwistDownDocument = twistDownDocument;
  1819. fTwistDownView = twistDownDocument -> fTwistDownView;
  1820. }
  1821. //----------------------------------------------------------------------------------------
  1822. //    TCollapseAllCommand::ICollapseAllCommand:    
  1823. //----------------------------------------------------------------------------------------
  1824. #pragma segment ASelCommand
  1825. void TCollapseAllCommand::ICollapseAllCommand(TTwistDownDocument* twistDownDocument, TCommandHandler* itsContext, 
  1826.                                                                                         const AppleEvent& itsMessage, const AppleEvent& itsReply)
  1827. {
  1828. fSuspendTheEvent = TRUE;    //For debugging fun and games, comment this out. Everything
  1829.                                                     //will work fine until you encounter low memory conditions
  1830.                                                     //and fail. Then all bets are off. Note that it must be set
  1831.                                                     //before IServerCommand is called.
  1832.                                                     
  1833. this -> IServerCommand(cCollapseAll,itsContext,kCantUndo, kDoesNotCauseChange,NULL,itsMessage,itsReply);
  1834.  
  1835. fTwistDownDocument = twistDownDocument;
  1836. fTwistDownView = twistDownDocument -> fTwistDownView;
  1837. }
  1838. //----------------------------------------------------------------------------------------
  1839. // TCollapseAllCommand::MakeAppleEvent:        Scripting Support    
  1840. //----------------------------------------------------------------------------------------
  1841. #pragma segment ACommandRes
  1842. TAppleEvent* TCollapseAllCommand::MakeAppleEvent()
  1843. {
  1844.  
  1845.     MAVolatileInit(TAppleEvent*, theCollapseAllEvent, NULL);
  1846.  
  1847.     FailInfo fi;
  1848.         Try(fi)
  1849.         {    
  1850.  
  1851.             theCollapseAllEvent = new TAppleEvent;    
  1852.             theCollapseAllEvent -> IAppleEvent(kAETwistDownListsSuite, kAECollapseAllID,gServerAddress, kAENoReply);
  1853.             {
  1854.                 CTempDesc    directObjectDesc;
  1855.                 if (gAppleEventRouting == routeToDoc)
  1856.                     fTwistDownDocument -> MakeObjectSpecifier(directObjectDesc, fTwistDownDocument -> GetSpecifierForm());
  1857.                 else if (gAppleEventRouting == routeToView)
  1858.                     fTwistDownView -> MakeObjectSpecifier(directObjectDesc, fTwistDownView -> GetSpecifierForm());
  1859.  
  1860.             theCollapseAllEvent -> WriteParameter(keyDirectObject, directObjectDesc);
  1861.             }
  1862.             fi.Success();
  1863.         }
  1864.         else // Recover
  1865.         {
  1866.             theCollapseAllEvent = (TAppleEvent *)FreeIfObject(theCollapseAllEvent);
  1867.             fi.ReSignal();
  1868.         }
  1869.         
  1870.     return theCollapseAllEvent;
  1871.  
  1872. }
  1873. //----------------------------------------------------------------------------------------
  1874. //    TCollapseAllCommand::DoIt:    
  1875. //----------------------------------------------------------------------------------------
  1876. #pragma segment ADoCommand
  1877. void TCollapseAllCommand::DoIt()
  1878. {
  1879.  
  1880.     fTwistDownDocument -> CollapseAll();
  1881.     //just set fNumberOfCollapsedControls to fInitialNumberOfControls
  1882.     //and set fNumberOfExpandedControls to 0.
  1883.     fTwistDownView -> SetCantCollapseAll();    //Will cause the cCollapseAll command to be disabled.
  1884.         
  1885. }
  1886. //========================================================================================
  1887. // CLASS TExpandElementCommand    
  1888. //========================================================================================
  1889. #undef Inherited
  1890. #define Inherited TServerCommand
  1891.  
  1892. #pragma segment ARes
  1893. MA_DEFINE_CLASS_M1(TExpandElementCommand, Inherited);
  1894. //----------------------------------------------------------------------------------------
  1895. // TExpandElementCommand::TExpandElementCommand: 
  1896. //----------------------------------------------------------------------------------------
  1897. #pragma segment ARes
  1898. TExpandElementCommand::TExpandElementCommand()
  1899. {
  1900. fTwistDownDocument = NULL;
  1901. fTwistDownView = NULL;
  1902. fElementToExpand = NULL;
  1903.  
  1904. fOldNumberOfExpandedControls = 0;
  1905. fOldNumberOfCollapsedControls = 0;
  1906.  
  1907. #if qDebug
  1908. this -> PrintAppConstructorClassInfo();
  1909. #endif
  1910. }
  1911. //----------------------------------------------------------------------------------------
  1912. // TExpandElementCommand::~TExpandElementCommand: 
  1913. //----------------------------------------------------------------------------------------
  1914. #pragma segment ARes
  1915. TExpandElementCommand::~TExpandElementCommand()
  1916. {
  1917. fTwistDownDocument = NULL;
  1918. fTwistDownView = NULL;
  1919. fElementToExpand = NULL;
  1920.  
  1921. fOldNumberOfExpandedControls = 0;
  1922. fOldNumberOfCollapsedControls = 0;
  1923.  
  1924. #if qDebug
  1925. this -> PrintAppDestructorClassInfo();
  1926. #endif
  1927. }
  1928. //----------------------------------------------------------------------------------------
  1929. //    TExpandElementCommand::IExpandElementCommand:    
  1930. //----------------------------------------------------------------------------------------
  1931. #pragma segment ASelCommand
  1932. void TExpandElementCommand::IExpandElementCommand(TTwistDownDocument* twistDownDocument, 
  1933.                                                     TTwistDownElement* elementToExpand)
  1934. {
  1935.  
  1936. this -> IServerCommand(cExpandElement,fTwistDownDocument,kCantUndo, kDoesNotCauseChange,NULL);
  1937.  
  1938. fTwistDownDocument = twistDownDocument;
  1939. fTwistDownView = twistDownDocument -> fTwistDownView;
  1940. fElementToExpand = elementToExpand;
  1941.  
  1942. fOldNumberOfExpandedControls = fTwistDownView -> GetNumberOfExpandedControls();
  1943. fOldNumberOfCollapsedControls = fTwistDownView -> GetNumberOfCollapsedControls();
  1944. }
  1945. //----------------------------------------------------------------------------------------
  1946. //    TExpandElementCommand::IExpandElementCommand:    
  1947. //----------------------------------------------------------------------------------------
  1948. #pragma segment ASelCommand
  1949. void TExpandElementCommand::IExpandElementCommand(TTwistDownDocument* twistDownDocument, 
  1950.                                                                         TTwistDownElement* elementToExpand, const AppleEvent& itsMessage, 
  1951.                                                                         const AppleEvent& itsReply)
  1952. {
  1953. fSuspendTheEvent = TRUE;    //For debugging fun and games, comment this out. Everything
  1954.                                                     //will work fine until you encounter low memory conditions
  1955.                                                     //and fail. Then all bets are off. Note that it must be set
  1956.                                                     //before IServerCommand is called.
  1957.                                                     
  1958. this -> IServerCommand(cExpandElement,twistDownDocument,kCantUndo,kDoesNotCauseChange,NULL,
  1959.                                                                                                                                                 itsMessage,itsReply);
  1960.  
  1961. fTwistDownDocument = twistDownDocument;
  1962. fTwistDownView = twistDownDocument -> fTwistDownView;
  1963. fElementToExpand = elementToExpand;
  1964.  
  1965. fOldNumberOfExpandedControls = fTwistDownView -> GetNumberOfExpandedControls();
  1966. fOldNumberOfCollapsedControls = fTwistDownView -> GetNumberOfCollapsedControls();
  1967. }
  1968. //----------------------------------------------------------------------------------------
  1969. // TExpandElementCommand::MakeAppleEvent:        Scripting Support    
  1970. //----------------------------------------------------------------------------------------
  1971. #pragma segment ACommandRes
  1972. TAppleEvent* TExpandElementCommand::MakeAppleEvent()
  1973. {
  1974.     MAVolatileInit(TAppleEvent*, theExpandElementEvent, NULL);
  1975.     
  1976.     FailInfo fi;
  1977.         Try(fi)
  1978.         {
  1979.             theExpandElementEvent = new TAppleEvent;
  1980.             theExpandElementEvent -> IAppleEvent(kAETwistDownListsSuite, kAEExpandElementID,gServerAddress, kAENoReply);
  1981.             {
  1982.                 
  1983.                 CTempDesc    targetObjectDesc;        
  1984.                 fElementToExpand -> MakeObjectSpecifier(targetObjectDesc, fElementToExpand -> GetSpecifierForm());
  1985.                 theExpandElementEvent -> WriteParameter(keyDirectObject, targetObjectDesc);    
  1986.  
  1987.             }
  1988.             fi.Success();
  1989.         }
  1990.         else // Recover
  1991.         {
  1992.             theExpandElementEvent = (TAppleEvent *)FreeIfObject(theExpandElementEvent);
  1993.             fi.ReSignal();
  1994.         }
  1995.         
  1996.     return theExpandElementEvent;
  1997.     
  1998. }
  1999. //----------------------------------------------------------------------------------------
  2000. //    TExpandElementCommand::DoIt:    
  2001. //----------------------------------------------------------------------------------------
  2002. #pragma segment ADoCommand
  2003. void TExpandElementCommand::DoIt()
  2004. {
  2005. FailInfo fi;
  2006. Try(fi)
  2007.     {    
  2008.         fTwistDownDocument -> ExpandElement(fElementToExpand);
  2009.         //I've got to increment fNumberOfExpandedControls here 
  2010.         //and decrement fNumberOfCollapsedControls here to account for the 
  2011.         //twistDownControl being expanded. All other controls will
  2012.         //take care of themselves.
  2013.         fTwistDownView -> IncrementNumberOfExpandedControls();
  2014.         fTwistDownView -> DecrementNumberOfCollapsedControls();
  2015.         fTwistDownView -> SetTheCouldFlags();
  2016.         
  2017.         fi.Success();
  2018.     }
  2019. else
  2020.     {
  2021.         //If there is a failure, it most likely will occur because an out of memory condition
  2022.         //occurred while making a new control. To recover, we need to collapse the twistDownElement.
  2023.         fTwistDownDocument -> CollapseElement(fElementToExpand);
  2024.         fTwistDownView -> SetNumberOfExpandedControlsTo(fOldNumberOfExpandedControls);
  2025.         fTwistDownView -> SetNumberOfCollapsedControlsTo(fOldNumberOfCollapsedControls);
  2026.         fTwistDownView -> SetTheCouldFlags();
  2027.         fi.ReSignal();
  2028.     }
  2029. }
  2030. //========================================================================================
  2031. // CLASS TCollapseElementCommand    
  2032. //========================================================================================
  2033. #undef Inherited
  2034. #define Inherited TServerCommand
  2035.  
  2036. #pragma segment ARes
  2037. MA_DEFINE_CLASS_M1(TCollapseElementCommand, Inherited);
  2038. //----------------------------------------------------------------------------------------
  2039. // TCollapseElementCommand::TCollapseElementCommand: 
  2040. //----------------------------------------------------------------------------------------
  2041. #pragma segment ARes
  2042. TCollapseElementCommand::TCollapseElementCommand()
  2043. {
  2044. fTwistDownDocument = NULL;
  2045. fTwistDownView = NULL;
  2046. fElementToCollapse = NULL;
  2047.  
  2048. #if qDebug
  2049. this -> PrintAppConstructorClassInfo();
  2050. #endif
  2051. }
  2052. //----------------------------------------------------------------------------------------
  2053. // TCollapseElementCommand::~TCollapseElementCommand: 
  2054. //----------------------------------------------------------------------------------------
  2055. #pragma segment ARes
  2056. TCollapseElementCommand::~TCollapseElementCommand()
  2057. {
  2058. fTwistDownDocument = NULL;
  2059. fTwistDownView = NULL;
  2060. fElementToCollapse = NULL;
  2061.  
  2062. #if qDebug
  2063. this -> PrintAppDestructorClassInfo();
  2064. #endif
  2065. }
  2066. //----------------------------------------------------------------------------------------
  2067. //    TCollapseElementCommand::ICollapseElementCommand:    
  2068. //----------------------------------------------------------------------------------------
  2069. #pragma segment ASelCommand
  2070. void TCollapseElementCommand::ICollapseElementCommand(TTwistDownDocument* twistDownDocument, 
  2071.                                                         TTwistDownElement* elementToCollapse)
  2072. {
  2073. this -> IServerCommand(cCollapseElement,twistDownDocument,kCantUndo, kDoesNotCauseChange,NULL);
  2074. fTwistDownDocument = twistDownDocument;
  2075. fTwistDownView = twistDownDocument -> fTwistDownView;
  2076. fElementToCollapse = elementToCollapse;
  2077. }
  2078. //----------------------------------------------------------------------------------------
  2079. //    TCollapseElementCommand::ICollapseElementCommand:    
  2080. //----------------------------------------------------------------------------------------
  2081. #pragma segment ASelCommand
  2082. void TCollapseElementCommand::ICollapseElementCommand(TTwistDownDocument* twistDownDocument, 
  2083.                                                     TTwistDownElement* elementToCollapse, const AppleEvent& itsMessage, 
  2084.                                                                             const AppleEvent& itsReply)
  2085. {
  2086. fSuspendTheEvent = TRUE;    //For debugging fun and games, comment this out. Everything
  2087.                                                     //will work fine until you encounter low memory conditions
  2088.                                                     //and fail. Then all bets are off. Note that it must be set
  2089.                                                     //before IServerCommand is called.
  2090.                                                     
  2091. this -> IServerCommand(cCollapseElement,twistDownDocument,kCantUndo,kDoesNotCauseChange,NULL,
  2092.                                                                                                                                                 itsMessage,itsReply);
  2093.  
  2094. fTwistDownDocument = twistDownDocument;
  2095. fTwistDownView = twistDownDocument -> fTwistDownView;
  2096. fElementToCollapse = elementToCollapse;                                                    
  2097. }
  2098. //----------------------------------------------------------------------------------------
  2099. // TCollapseElementCommand::MakeAppleEvent:        Scripting Support    
  2100. //----------------------------------------------------------------------------------------
  2101. #pragma segment ACommandRes
  2102. TAppleEvent* TCollapseElementCommand::MakeAppleEvent()
  2103. {
  2104.  
  2105.     MAVolatileInit(TAppleEvent*, theCollapseElementEvent, NULL);
  2106.     
  2107.     FailInfo fi;
  2108.         Try(fi)
  2109.         {
  2110.             theCollapseElementEvent = new TAppleEvent;
  2111.             theCollapseElementEvent -> IAppleEvent(kAETwistDownListsSuite,kAECollapseElementID,gServerAddress,kAENoReply);
  2112.             {
  2113.                 
  2114.                 CTempDesc    directObjectDesc;        
  2115.                 fElementToCollapse -> MakeObjectSpecifier(directObjectDesc, fElementToCollapse -> GetSpecifierForm());
  2116.                 theCollapseElementEvent -> WriteParameter(keyDirectObject, directObjectDesc);    
  2117.  
  2118.             }
  2119.             fi.Success();
  2120.         }
  2121.         else // Recover
  2122.         {
  2123.             theCollapseElementEvent = (TAppleEvent *)FreeIfObject(theCollapseElementEvent);
  2124.             fi.ReSignal();
  2125.         }
  2126.         
  2127.     return theCollapseElementEvent;
  2128.  
  2129. }
  2130. //----------------------------------------------------------------------------------------
  2131. //    TCollapseElementCommand::DoIt:    
  2132. //----------------------------------------------------------------------------------------
  2133. #pragma segment ADoCommand
  2134. void TCollapseElementCommand::DoIt()
  2135. {
  2136.  
  2137.     fTwistDownDocument -> CollapseElement(fElementToCollapse);
  2138.     //I've got to increment fNumberOfCollapsedControls here 
  2139.     //and decrement fNumberOfExpandedControls here to account for the 
  2140.     //twistDownControl being collapsed. All other controls will take
  2141.     //care of themselves.
  2142.     fTwistDownView -> IncrementNumberOfCollapsedControls();
  2143.     fTwistDownView -> DecrementNumberOfExpandedControls();        
  2144.     fTwistDownView -> SetTheCouldFlags();
  2145.  
  2146. }
  2147. #pragma segment Inline